import java.util.Scanner;

public class TestDemo {

//=================================     作业讲解    ================================
//    几道作业题

    //    计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值 。
    public static void main02(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        double ret = sumDiv(n);
        System.out.println(ret);
    }

    public static double sumDiv(int n) {
        double sum = 0.0;
        int flag = 1;
        for (int i = 1; i <= n; i++) {
            sum += 1.0 / i * flag;
            flag *= -1;
        }
        return sum;
    }

//    输出一个整数的每一位，如：123的每一位是3，2，1
//    public static void main(String[] args) {
//        Scanner scan=new Scanner(System.in);
//        int n=scan.nextInt();
//        while (n>0) {
//            System.out.println(n%10);
//            n/=10;
//        }
//    }

//    编写代码模拟三次密码输入的场景。 最多能输入三次密码，密码正确，提示“登录成功”,密码错误，
//    可以重新输 入，最多输入三次。三次均错，则提示退出程序
//    public static void main(String[] args) {
//        String passWord="123456";
//        Scanner scan=new Scanner(System.in);
//        int n=3;
//        while(n>0) {
//            System.out.print("请输入密码，你有"+n+"次机会:>");
//            String str=scan.nextLine();
//            //java中比较字符串相等时用equals
//            if(str.equals(passWord)) {
//                System.out.println("密码正确！开锁成功！");
//                break;
//            }else {
//                System.out.println("密码错误！");
//            }
//            n--;
//        }
//    }

    //    输出n*n的乘法口诀表，n由用户输入
    public static void main03(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        printMul(n);
    }

    public static void printMul(int n) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.printf("%-2d*%-2d=%-2d", i, j, i * j);
            }
            System.out.println();
        }
    }

    //    创建方法求两个数的最大值max2，随后再写一个求3个数的最大值的函数max3。
//    要求：在max3这个函数中，调用max2函数，来实现3个数的最大值计算
    public static void main04(String[] args) {
        double ret1 = max2(5, 8);
        double ret2 = max3(4, 49, 8);
        System.out.println(ret1);
        System.out.println(ret2);
    }

    public static double max2(double x, double y) {
        return (x > y ? x : y);
    }

    public static double max3(double x, double y, double z) {
        double tmp = max2(x, y);
        return max2(tmp, z);
//        return (max2(x,y)>z?max2(x,y):z);
    }

    //    求斐波那契数列的第n项。(递归实现)
    public static void main05(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int ret = fib2(n);
        System.out.println(ret);
    }

    public static int fib(int n) {
        int fib1 = 1;
        int fib2 = 1;
        if (n <= 2) {
            return 1;
        }
        return fib(n - 1) + fib(n - 2);
    }

    //    （迭代实现）滚雪球
    public static int fib2(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        int fib1 = 1;
        int fib2 = 1;
        int fib3 = 0;

        for (int i = 3; i <= n; i++) {
            fib3 = fib1 + fib2;
            fib1 = fib2;
            fib2 = fib3;
        }
        return fib3;
    }


    //方法重载

    //    在同一个类中,分别定义求两个整数的方法 和 三个小数之和的方法。 并执行代码，求出结果
    public static void main06(String[] args) {
        int ret1 = sum(5, 8);
        double ret2 = sum(1.0, 1.2, 1.3);
        System.out.println(ret1);
        System.out.println(ret2);
    }

    public static int sum(int x, int y) {
        return x + y;
    }

    public static double sum(double x, double y, double z) {
        return x + y + z;
    }

    //    在同一个类中定义多个方法：要求不仅可以求2个整数的最大值，还可以求3个小数的最大值？
    public static void main07(String[] args) {
        int ret1 = max(3, 7);
        double ret2 = max(1.2, 3.1, 5.6);
        System.out.println(ret1);
        System.out.println(ret2);
    }

    public static int max(int x, int y) {
        return (x > y ? x : y);
    }

    public static double max(double x, double y, double z) {
        return ((x > y ? x : y) > z ? (x > y ? x : y) : z);
    }

//======================================作业分割线===================================
















//======================================方法的使用===================================


    public static void main01(String[] args) {
//        public static 访问修饰限定符 + 返回值 +方法名 + （形式参数列表）{
//        方法体
//    }
    }

//    方法概述

//调用一个方法的语法：add();
//一个方法从写好到用起来
//1.定义方法，决定这个方法，返回值是什么类型？方法名叫啥？形参有几个？什么类型？什么顺序？
//2.使用这个方法，调用这个方法。方法名()->看一下有几个参数，都是啥类型？都有啥顺序？
//3.方法有返回值吗？要不要接受？拿什么类型接受?接受了返回值，我用返回值干啥？
//4.方法的调用是在栈上的，当方法遇到return或者右花括号就代表方法结束了。对应方法开辟的栈帧就回收了。
//5，在java中同样是改变形参不改变实参，在学习了类和对象之后才能解决这个问题。

    public static boolean isleapYear(int year) {
//        这里使用了小驼峰命名法
        if((0==year%4 && 0!=year%100) || 0==year%400) {
            return true;
        } else {
            return false;
        }

    }

//    方法重载

//1.方法名称必须相同
//2.方法的参数列表不同（顺序、个数、类型）
//3.和返回值没有关系




//    递归
//1.自己调用自己
//2.有一个终止条件（一定要有终止条件）否则栈溢出只能由程序员解决
//3.最难的地方就是如何能够确定这个递归公式！！！


    //递归练习
    //1、求阶乘
    public static int recursion(int n) {
        if(n==1) {
            return 1;
        }else {
            return n*recursion(n-1);
        }
    }

    //2、正序输出整数每一位
    public static void print1(int n) {
        if(n>=10) {
            print1(n/10);
        }
        System.out.println(n%10);
    }

    public static void print2(int n) {
        if(n<=9) {
            System.out.println(n%10);
            return;
        }
        print2(n/10);
        System.out.println(n%10);
    }
    public static void main1(String[] args) {
        print2(1234);

    }
}

//递归和循环有什么区别？
//递归的好处：代码少
//递归不好的：不好书写,浪费空间比较多
//
//循环的好处：容易理解


//天生用递归：汉诺塔